home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / networking / amitcp / wu-ftpd-37.21.lha / wu-ftpd / src / acl.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-08  |  5.8 KB  |  170 lines
  1. /* Copyright (c) 1993, 1994  Washington University in Saint Louis
  2.  * All rights reserved.
  3.  *
  4.  * Redistribution and use in source and binary forms, with or without
  5.  * modification, are permitted provided that the following conditions are
  6.  * met: 1. Redistributions of source code must retain the above copyright
  7.  * notice, this list of conditions and the following disclaimer. 2.
  8.  * Redistributions in binary form must reproduce the above copyright notice,
  9.  * this list of conditions and the following disclaimer in the documentation
  10.  * and/or other materials provided with the distribution. 3. All advertising
  11.  * materials mentioning features or use of this software must display the
  12.  * following acknowledgement: This product includes software developed by the
  13.  * Washington University in Saint Louis and its contributors. 4. Neither the
  14.  * name of the University nor the names of its contributors may be used to
  15.  * endorse or promote products derived from this software without specific
  16.  * prior written permission.
  17.  *
  18.  * THIS SOFTWARE IS PROVIDED BY WASHINGTON UNIVERSITY AND CONTRIBUTORS
  19.  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21.  * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL WASHINGTON
  22.  * UNIVERSITY OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  23.  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  24.  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  25.  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  26.  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  28.  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29.  * POSSIBILITY OF SUCH DAMAGE.
  30.  */
  31.  
  32. #include "config.h"
  33.  
  34. #include <stdio.h>
  35. #include <errno.h>
  36. #include <string.h>
  37. #ifdef SYSSYSLOG
  38. #include <sys/syslog.h>
  39. #else
  40. #include <syslog.h>
  41. #endif
  42.  
  43. #include <sys/types.h>
  44. #include <sys/stat.h>
  45. #include <sys/file.h>
  46.  
  47. #include "pathnames.h"
  48. #include "extensions.h"
  49.  
  50. char *aclbuf = NULL;
  51. static struct aclmember *aclmembers;
  52.  
  53. /*************************************************************************/
  54. /* FUNCTION  : getaclentry                                               */
  55. /* PURPOSE   : Retrieve a named entry from the ACL                       */
  56. /* ARGUMENTS : pointer to the keyword and a handle to the acl members    */
  57. /* RETURNS   : pointer to the acl member containing the keyword or NULL  */
  58. /*************************************************************************/
  59.  
  60. struct aclmember *
  61. getaclentry(char *keyword, struct aclmember **next)
  62. {
  63.     do {
  64.         if (!*next)
  65.             *next = aclmembers;
  66.         else
  67.             *next = (*next)->next;
  68.     } while (*next && strcmp((*next)->keyword, keyword));
  69.  
  70.     return (*next);
  71. }
  72.  
  73. /*************************************************************************/
  74. /* FUNCTION  : parseacl                                                  */
  75. /* PURPOSE   : Parse the acl buffer into its components                  */
  76. /* ARGUMENTS : A pointer to the acl file                                 */
  77. /* RETURNS   : nothing                                                   */
  78. /*************************************************************************/
  79.  
  80. void
  81. parseacl(void)
  82. {
  83.     char *ptr,
  84.      *aclptr = aclbuf,
  85.      *line;
  86.     int cnt;
  87.     struct aclmember *member,
  88.      *acltail;
  89.  
  90.     if (!aclbuf || !(*aclbuf))
  91.         return;
  92.  
  93.     aclmembers = (struct aclmember *) NULL;
  94.     acltail = (struct aclmember *) NULL;
  95.  
  96.     while (*aclptr != NULL) {
  97.         line = aclptr;
  98.         while (*aclptr && *aclptr != '\n')
  99.             aclptr++;
  100.         *aclptr++ = (char) NULL;
  101.  
  102.         /* deal with comments */
  103.         if ((ptr = strchr(line, '#')) != NULL)
  104.             /* allowed escaped '#' chars for path-filter (DiB) */
  105.             if (*(ptr-1) != '\\')
  106.                 *ptr = NULL;
  107.  
  108.         ptr = strtok(line, " \t");
  109.         if (ptr) {
  110.             member = (struct aclmember *) calloc(1, sizeof(struct aclmember));
  111.  
  112.             (void) strcpy(member->keyword, ptr);
  113.             cnt = 0;
  114.             while ((ptr = strtok(NULL, " \t")) != NULL)
  115.                 member->arg[cnt++] = ptr;
  116.             if (acltail)
  117.                 acltail->next = member;
  118.             acltail = member;
  119.             if (!aclmembers)
  120.                 aclmembers = member;
  121.         }
  122.     }
  123. }
  124.  
  125. /*************************************************************************/
  126. /* FUNCTION  : readacl                                                   */
  127. /* PURPOSE   : Read the acl into memory                                  */
  128. /* ARGUMENTS : The pathname of the acl                                   */
  129. /* RETURNS   : 0 if error, 1 if no error                                 */
  130. /*************************************************************************/
  131.  
  132. int
  133. readacl(char *aclpath)
  134. {
  135.     FILE *aclfile;
  136.     struct stat finfo;
  137.     extern int use_accessfile;
  138.  
  139.     if (!use_accessfile)
  140.         return (0);
  141.  
  142.     if (stat(aclpath, &finfo) != 0) {
  143.         syslog(LOG_ERR, "cannot stat access file %s: %s", aclpath,
  144.                strerror(errno));
  145.         return (0);
  146.     }
  147.     if ((aclfile = fopen(aclpath, "r")) == NULL) {
  148.         if (errno != ENOENT)
  149.             syslog(LOG_ERR, "cannot open access file %s: %s",
  150.                    aclpath, strerror(errno));
  151.         return (0);
  152.     }
  153.     if (finfo.st_size == 0) {
  154.         aclbuf = (char *) calloc(1, 1);
  155.     } else {
  156.         if (!(aclbuf = malloc((unsigned) finfo.st_size + 1))) {
  157.             syslog(LOG_ERR, "could not malloc aclbuf (%d bytes)", finfo.st_size + 1);
  158.             return (0);
  159.         }
  160.         if (!fread(aclbuf, (size_t) finfo.st_size, 1, aclfile)) {
  161.             syslog(LOG_ERR, "error reading acl file %s: %s", aclpath,
  162.                    strerror(errno));
  163.             aclbuf = NULL;
  164.             return (0);
  165.         }
  166.         *(aclbuf + finfo.st_size) = '\0';
  167.     }
  168.     return (1);
  169. }
  170.